import { Delete, Get, Injectable, Param, Post } from '@nestjs/common';
import { CreateConfigInfoDto, CreateRecordDto } from './create-record.dto';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Record } from './record.entity';

interface Response {
  message: string;
  code: number;
  data?: any[];
}

@Injectable()
export class RecordService {
  constructor(
    @InjectRepository(Record)
    private recordRepository: Repository<Record>, // 注入Repository
  ) {}

  // 用于获取所有配置信息
  @Get('findAllInfo')
  async findAllInfo(): Promise<Response> {
    try {
      const records = await this.recordRepository.find({
        where: { type: 'config' }, // 只查询 type 为 config 的数据
      }); // 使用 Repository 查询数据

      // 返回成功信息和数据
      return {
        message: '查询成功',
        code: 200,
        data: records,
      };
    } catch (error) {
      // 返回错误信息和空数据
      return {
        message: `${error}`,
        code: 400,
        data: [],
      };
    }
  }

  // 用于删除配置信息
  @Delete('deleteInfo/:id')
  async deleteInfo(@Param('id') id: string): Promise<Response> {
    try {
      // 查找指定 id 的记录
      const record = await this.recordRepository.findOne({
        where: { id, type: 'config' }, // 只查找 type 为 config 的记录
      });

      if (!record) {
        return {
          message: '未找到该配置记录',
          code: 404,
          data: [],
        };
      }

      // 删除记录
      await this.recordRepository.remove(record);

      return {
        message: '配置已成功删除',
        code: 200,
      };
    } catch (error) {
      return {
        message: `${error}`,
        code: 400,
        data: [],
      };
    }
  }

  // 用于保存所有配置信息
  @Post('saveAllInfo')
  async saveAllInfo(body: CreateConfigInfoDto): Promise<Response> {
    const { data } = body;
    try {
      // 保存时设置 type 为 config
      const newRecord = this.recordRepository.create({
        data,
        type: 'config',
      });

      await this.recordRepository.save(newRecord);

      return {
        message: '配置已成功保存',
        code: 200,
      };
    } catch (error) {
      return {
        message: `${error}`,
        code: 400,
        data: [],
      };
    }
  }

  // 用于修改所有配置信息
  @Post('modifyAllInfo')
  async modifyAllInfo(body: CreateConfigInfoDto): Promise<Response> {
    const { data, id } = body;
    try {
      // 使用 TypeORM 保存录制数据
      const newRecord = this.recordRepository.create({
        id,
        data,
      });

      await this.recordRepository.save(newRecord);
      return {
        message: '配置修改成功',
        code: 200,
      };
    } catch (error) {
      return {
        message: `${error}`,
        code: 400,
        data: [],
      };
    }
  }

  // 用于获取录制数据
  @Get('getRecording')
  async getRecording(): Promise<Response> {
    try {
      const records = await this.recordRepository.find({
        where: { type: 'recording' }, // 只查询 type 为 config 的数据
      }); // 使用 Repository 查询数据

      // 返回成功信息和数据
      return {
        message: '查询成功',
        code: 200,
        data: records,
      };
    } catch (error) {
      // 返回错误信息和空数据
      return {
        message: `${error}`,
        code: 400,
        data: [],
      };
    }
  }

  // 用于保存录制数据
  @Post('saveRecording')
  async saveRecording(body: CreateRecordDto): Promise<Response> {
    const { events, timestamp } = body;

    try {
      // 使用 TypeORM 保存录制数据
      // 保存时设置 type 为 recording
      const newRecord = this.recordRepository.create({
        timestamp,
        events,
        type: 'recording',
      });

      await this.recordRepository.save(newRecord);

      return {
        message: '数据保存成功',
        code: 200,
      };
    } catch (error) {
      return {
        message: `${error}`,
        code: 400,
        data: [],
      };
    }
  }
}
